package com.guqj.basis.innerclass;

import org.junit.Test;

/**
 * 编译后会生成两个类，一个是MethodOuter, 一个MethodOuter$1Inner.class
 * 
 * public MethodOuter{
 *   private int shared = 100;
 *   
 *   static int access$0(MethodOuter outer){
        return outer.shared;
    }
 * 
 *  public void invoke(final int param) {
 *    final String str = "str";
 *    MethodOuter$1Inner inner = new MethodOuter$1Inner(this, param);
      inner.invoke();
 *  }
 * }
 * 
 * public class MethodOuter$1Inner{
 *   final MethodOuter this$0;
 *   int param;
 *   
 *   MethodOuter$1Inner(MethodOuter pouer, int param){
 *     this.this$0 = outer;
       this.param = param;
 *   }
 *   
 *   public void invoke() {
        System.out.println(MethodOuter.access$0(this$0));
        System.out.println("param " + param);
        System.out.println("str");
    }
 * }
 * @author guqj
 * @date 2017年3月30日
 */
public class MethodOuter {

	private int shared = 100;

	public void invoke(final int param) {
		final String str = "str";
		/**
		 * 方法内部类只能在定义的方法内被使用,如果方法是实例方法，则除了静态变量和方法，内部类还可以直接访问外部类的实例变量和方法,
		 * 如果方法是静态方法，则方法内部类只能访问外部类的静态变量和方法。
		 * 方法内部类还可以直接访问方法的参数和方法中的局部变量，不过，这些变量必须被声明为final。
		 */
		class Inner {
			public void invoke() {
				System.out.println(shared);
				System.out.println(param);
				System.out.println(str);
			}
		}

		Inner inner = new Inner();
		inner.invoke();
	}

	@Test
	public void test() {
		MethodOuter outer = new MethodOuter();
		outer.invoke(10);
	}
}
